/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package aso.upna.threads;

import aso.upna.filesystem.SharedFolder;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.Socket;

/**
 *
 * @author triki
 */
public class ClientAcceptedThread implements Runnable {

    private Socket sock;
    private SharedFolder shared;

    public ClientAcceptedThread(Socket s,String path)
    {
        sock = s;
        shared = new SharedFolder(path,".mp3");
    }

    /*
     Nos mantendremos a la espera de recibir la peticion de cancion.
     Cuando recibamos el nombre de la cancion, le enviaremos un OK si
     la cancion se encuentra disponible. Acto seguido abriremos el
     fichero y le enviaremos la cancion. Si la cancion no se encuentra
     disponible, le mandaremos un FAIL.

     * Descripcion de los mensajes:
     * Reproducir una cancion.
        -Cliente remoto: "PLAY filexxx.mp3"
        -Cliente local: "OK :: [filesize en bytes]"
        -Cliente local: "FAIL"
    
     La conexion se cierra cuando se termina de enviar la cancion.
     */

    public void run()
    {   
        ObjectInputStream oisd = null;
        ObjectOutputStream oosd = null;

        boolean end = false;
        byte[] message = new byte[1024];
        String sMessage = null;
        String[] parts;
        String filename = null;
        int remotePort = 0;
        DatagramSocket dgram;
        DatagramPacket dPack;
        byte[] aux = new byte[2048];
        InetAddress inaddr;

        try
        {
            oosd = new ObjectOutputStream(sock.getOutputStream());
            oisd = new ObjectInputStream(sock.getInputStream());
    
            inaddr = sock.getInetAddress();
            
            int j = 0;
            int read;
            Object obaux = null;

            //FileInputStream ifile = new FileInputStream(f);
            while (true)
            {
                System.out.println("esperando a leer objeto");
                obaux = oisd.readObject();
                
                if(obaux instanceof String)
                {
                    sMessage = (String)obaux;
                    System.out.println("Mensaje Recibido: "+new String(message));
                    parts = sMessage.split(" ");

                    if(parts[0].regionMatches(true, 0, "PLAY", 0, 4))
                    {
                        System.out.println("fichero: "+parts[1]);
                        System.out.println("Remote Port: \""+parts[2]+"\"");
                        filename = new String(parts[1]);
                        remotePort = Integer.parseInt(parts[2].substring(0, parts[2].length()));

                        //buscamos la cancion
                        //Si la cancion existe, en enviamos un OK y el
                        //tamaño en bytes del fichero
                        if(shared.searchFile(parts[1]) && parts[2]!=null)
                        {
                            long aux2 = new File(shared.getPath()+filename).length();
                            String cad = new String("OK "+aux2);
                            oosd.writeObject(cad);
                            break;
                        }
                        else
                        {
                            String cad = new String("FAIL");
                            oosd.writeObject(cad);
                        }
                        //Sino le enviamos un fail y seguimos a la espera.
                    }
                }
                else
                    System.out.println("Tipo de mensaje no reconocido");
            }
            
            //En este punto ya podemos cerrar:
            //  - socket TCP
            //  - ObjectInput
            //  - ObjectOutput
            
            oosd.close();
            oisd.close();
            sock.close();
            
            //En este punto estamos seguros de podemos algo a un sitio seguro.
           
            System.out.println("Opening UDP socket..");
            //Abrimos un nuevo socket UDP.
            dgram = new DatagramSocket();

            File f = new File(shared.getPath()+filename);
            FileInputStream ifile = new FileInputStream(f);
            
            int size = 0;

            while(ifile.read(aux) > -1)
            {
                try
                {
                    dPack = new DatagramPacket(aux,2048,inaddr,remotePort);
                    dgram.send(dPack);
                    size+=2048;
                    //Esperamos 50ms para no atragantar el socket de recepcion
                    Thread.sleep(50);
                }
                catch (InterruptedException ex)
                {
                        ex.printStackTrace();
                }

            }

            dgram.close();
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }
}
